#include "widget.h"

#include <QApplication>
// #include "include/calcAR.h"
// #include "include/AR.h"
// #include "myadd/myadd.h"

// #include "ar/calcAR.h"
// #include "ar/calcAR_terminate.h"
// #include "ar/rt_nonfinite.h"
// #include "ar/coder_array.h"
// #include "myp/myp.h"
// #include "myp/myp_terminate.h"
// #include "myp/myp_types.h"


// #include "myinterp1/myinterp1.h"
// #include "myinterp1/myinterp1_terminate.h"
// #include "myinterp1/rt_nonfinite.h"
// #include "myinterp1/coder_array.h"

// // Function Declarations
// static coder::array<double, 2U> argInit_1xUnbounded_real_T();

// static double argInit_real_T();

// static void main_calcAR();
// static void main_myp();
// // Function Definitions
// //
// // Arguments    : void
// // Return Type  : coder::array<double, 2U>
// //
// static coder::array<double, 2U> argInit_1xUnbounded_real_T()
// {
//     coder::array<double, 2U> result;
//     // Set the size of the array.
//     // Change this size to the value that the application requires.
//     result.set_size(1, 2);
//     // Loop over the array to initialize each element.
//     for (int idx0{0}; idx0 < 1; idx0++) {
//         for (int idx1{0}; idx1 < result.size(1); idx1++) {
//             // Set the value of the array element.
//             // Change this value to the value that the application requires.
//             result[idx1] = argInit_real_T();
//         }
//     }
//     return result;
// }

// //
// // Arguments    : void
// // Return Type  : double
// //
// static double argInit_real_T()
// {
//     return 0.0;
// }

// //
// // Arguments    : void
// // Return Type  : void
// //
// static void main_calcAR()
// {
//     coder::array<double, 2U> t_tmp,y_tmp;
//     coder::array<double, 1U> F;
//     coder::array<double, 1U> PSD;
//     double fs_tmp=4;

//     t_tmp.set_size(1, 10);
//     y_tmp.set_size(1, 10);
//     // Loop over the array to initialize each element.
//     for (int idx0{0}; idx0 < 1; idx0++) {
//         for (int idx1{0}; idx1 < t_tmp.size(1); idx1++) {
//             // Set the value of the array element.
//             // Change this value to the value that the application requires.
//             t_tmp[idx1] = idx1;

//         }
//     }
//     //1,2,1.5,3,2.5,4,3.5,5,4.5,6
//     y_tmp[0]=1;y_tmp[1]=2;y_tmp[2]=1.5;y_tmp[3]=3;y_tmp[4]=2.5;y_tmp[5]=4;y_tmp[6]=3.5;y_tmp[7]=5;y_tmp[8]=4.5;y_tmp[9]=6;
//     // Initialize function 'calcAR' input arguments.
//     // Initialize function input argument 't'.
//     // t_tmp = argInit_1xUnbounded_real_T();
//     // Initialize function input argument 'y'.
//     // Call the entry-point 'calcAR'.

//     calcAR(t_tmp, y_tmp, fs_tmp, 100, 16, PSD, F);
//     qDebug()<<F.size(0)<<F.size(1);
//     for(int i=0;i<101;i++)
//     {
//         qDebug()<<"F="<<PSD.at(i);
//     }

//     qDebug()<<"PSD="<<PSD.data();
// }
// static void main_myp()
// {
//     struct0_T out;
//     double a_tmp11=3;
//     // Initialize function 'myp' input arguments.
//     double a_tmp12 = 2;
//     // Call the entry-point 'myp'.
//     myp(a_tmp11, a_tmp12, &out);
//     qDebug()<<out.c1<<out.c2;
// }
int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    // testAR();
    Widget w;
    w.show();
    return a.exec();
    // double a_tmp=2;
    // double b_tem = 3;
    // // Call the entry-point 'myadd'.
    // double c_tmp = myadd(a_tmp, b_tem);
    // qDebug() << "c_tmp="<<c_tmp;
    // main_calcAR();
    // calcAR_terminate();
    // main_myp();

    // coder::array<double, 2U> t1,t2,y1;
    // coder::array<double, 2U> y2;
    // t1.set_size(1,2);
    // t1[0]=0;t1[1]=1;
    // y1.set_size(1,2);
    // y1[0]=0;y1[1]=1;
    // t2.set_size(1,2);
    // t2[0]=0.1;t2[1]=0.25;
    // myinterp1(t1, y1, t2, y2);
    // qDebug()<<y2.at(0,1)<<y2.at(0,0);

    // double sourceData[] = {1.0, 3.0, 2.0, 4.0}; // 列主序：1,3 是第一列；2,4 是第二列
    // coder::array<double, 2U> tmp;
    // tmp.set_size(1,  4);
    // memcpy(tmp.data(),  sourceData, sizeof(double) * 4);
    // const coder::array<double, 2U> t = tmp;
    // qDebug()<<t.at(0,0)<<t.at(0,1)<<t.at(0,2)<<t.at(0,3);

}

// void testAR()
// {
//     mclOutputHandlerFcn error_handler;
//     mclOutputHandlerFcn print_handler;
//     if(!ARInitializeWithHandlers(error_handler, print_handler)){
//         qDebug()<<"初始化失败";
//         return;
//     }else{
//         qDebug()<<"初始化成功";
//     }
//     // if(!ARInitialize())
//     // {
//     //     qDebug()<<"初始化失败";
//     //     return;
//     // }else{
//     //     qDebug()<<"初始化成功";
//     // }
//     // 标量构造
//     mwArray nfft = mwArray(100); // double类型标量
//     mwArray fs = mwArray(4); // double类型标量
//     mwArray AR_order = mwArray(16); // double类型标量

//     // 向量构造
//     // double t[] = {0,1,2,3,4,5,6,7,8,9};
//     // double y[]={1,2,1.5,3,2.5,4,3.5,5,4.5,6};
//     // mwArray matt(1, 10, mxDOUBLE_CLASS); // 1x10矩阵
//     // matt.SetData(t, 10);
//     // mwArray maty(1, 10, mxDOUBLE_CLASS); // 1x10矩阵
//     // maty.SetData(y, 10);

//     // mwArray F,PSD;

//     // 字符串构造
//     mwArray str = "Hello MATLAB Engine";

//     // calcAR(int nargout, mwArray& PSD, mwArray& F, const mwArray& t, const mwArray& y, const mwArray& fs, const mwArray& nfft, const mwArray& AR_order);
//     qDebug()<<"1";
//     // mwArray c;
//     // myadd(1, c, fs, AR_order);
//     // qDebug()<<"2";
//     // qDebug()<<nfft.NumberOfDimensions();
//     qDebug()<<"3";
//     // calcAR(2, PSD, F, matt, maty, fs, nfft, AR_order);
//     // 提取数值数据
//     // 验证F的维度
//     // int fDims = F.NumberOfDimensions();
//     // mwArray fDimsArray = F.GetDimensions();
//     // qDebug() << "F维度：" << fDims << "维，尺寸[ ";
//     // for(int i=0; i<fDims; i++) qDebug() << fDimsArray[i] << " ";
//     // qDebug() << "]";

//     // 验证PSD的维度（同F类似操作）
// }
